home *** CD-ROM | disk | FTP | other *** search
/ PD ROM 1 / PD ROM Volume I - Macintosh Software from BMUG (1988).iso / Programming / Languages / Sesame C Compiler / asample.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-10-06  |  18.7 KB  |  653 lines  |  [TEXT/TWDA]
  1.  /*   SAMPLE C PROGRAM  */
  2.  
  3. /* This is just to show you how to get a Macintosh application */
  4. /* using this compiler.  Its style may not be the best, */
  5. /* but it does show you how.  For one thing, the whole thing */
  6. /* should be broken into separate files and compiled separatly */
  7. /* Separate compilation is just one of the neat things this  */
  8. /* compiler does. For more sample programs and documentation  */
  9. /* become a registered owner by paying for Sesame C. */
  10.  
  11. /* READ THE include file ~asample.inc for some general technical */
  12. /* information on using this compiler */
  13.  
  14. /* ASAMPLE.C is a simple editor.  It shows how to use almost every basic */
  15. /* thing you can do with Sesame C and the Macintosh environment. */
  16. /* It is simple and yet shows how you can get quite a lot from */
  17. /* the Macintosh routines, such as menus, windows, scrollbars, */
  18. /* and cut and paste textediting */
  19.  
  20. /* By the way, this takes quite a while to compile, mainly */
  21. /* because it is fair sized and filled with comments. */
  22. /* Separate compilation is really the way to go. */
  23.  
  24. #include ~asample.inc
  25.  
  26. /* Here are the program globals.  In other files (if there were any), */
  27. /* they would be declared extern (possibly in an include file) */
  28.  
  29.  char  seventrec[16],viewrect[8],pblock[100];
  30.  int   windptr,tehnd,scrollhnd; 
  31.  int   applemenu, filemenu, editmenu,curtop; 
  32.  
  33. start()   /* Must start with start  */
  34.           /* Used to initialize the Macintosh environment */
  35.  
  36. {
  37.     char  qdglob[206];
  38.   
  39.     TRAP(INITGRAF,&qdglob[202]:L);  /* screwy address, but correct */
  40.     TRAP(INITFONTS);
  41.     flushevents(-1);   /* flushevents is a registered routine, so we */
  42.                        /* can't use the TRAP directive */
  43.     TRAP(INITWINDOWS);
  44.     TRAP(INITMENUS);
  45.     TRAP(INITDIALOG,0:L);
  46.     TRAP(TEINIT);
  47.     TRAP(INITCURSOR);
  48.     main();
  49.  
  50. }
  51.  
  52. /* This is a normal structure for a Macintosh program. */
  53. /* First you do some setup stuff, then you loop though */
  54. /* an event loop forever until you quite.  You then */
  55. /* should unsetup yourself if necessary.  This program */
  56. /* takes the lazy way out and just ends, letting the Macintosh */
  57. /* finish up the cleanup */
  58.  
  59. main()
  60.  
  61. { 
  62. makemenu();
  63. openwindow("untitled");  /* start off with an open window */  
  64. while(events()==0);
  65. }
  66.  
  67. /* We just make a menu and keep it around.  Good style includes */
  68. /* enabling and disabling menu items depending on whether */
  69. /* they can be used.  */
  70.  
  71. makemenu()
  72.  
  73. {   char    pascalstr[256];
  74.  
  75.     ctopstr("*",pascalstr);
  76.     pascalstr[1]=20; /* set to apple icon */
  77.     applemenu=TRAP:L(NEWMENU,appleid:W,pascalstr);
  78.     ctopstr("Sample Sesame C Program;-;Modify at will",pascalstr);
  79.     TRAP(APPENDMENU,applemenu:L,pascalstr);
  80.     TRAP(INSERTMENU,applemenu:L,0:W);   /* insert in front */
  81.     
  82.     ctopstr("File",pascalstr);
  83.     filemenu=TRAP:L(NEWMENU,fileid:W,pascalstr);
  84.     ctopstr("New;Open;Close;Save;Save as...;Print;-;Quit/Q",pascalstr);
  85.     TRAP(APPENDMENU,filemenu:L,pascalstr);
  86.     TRAP(INSERTMENU,filemenu:L,0:W);   /* insert in front */
  87.  
  88.     ctopstr("Edit",pascalstr);
  89.     editmenu=TRAP:L(NEWMENU,editid:W,pascalstr);
  90.     ctopstr("Undo/Z;-;Cut/X;Copy/C;Paste/V;Clear;Select All/S",pascalstr);
  91.     TRAP(APPENDMENU,editmenu:L,pascalstr);
  92.     TRAP(INSERTMENU,editmenu:L,0:W);   /* insert in front */
  93.  
  94.     TRAP(DRAWMENUBAR);
  95.  
  96. }
  97.  
  98. openwindow(title)   /* Opens a window with the specified title */
  99.                     /* Note it does not open a file, just sets up the window */
  100.                     /* Also note, that for simplicity this application only */
  101.                     /* allows one window to be opened */
  102.    char    title[];
  103. { 
  104.    char    ptitle[64],boundrect[8],fontinfo[8];
  105.  
  106. /* The easiest way to define a window is with a resource.  This */
  107. /* is how you do it the old fashioned way  */
  108.  
  109. /* C and Pascal strings are completely different. */
  110. /* The Macintosh Toolbox understands only Pascal strings */
  111. /* Everytime you use a TRAP that expects a string or returns */
  112. /* a string you have to use these conversion functions.  They are */
  113. /* writen in assembler for speed's sake.  They expect two addreses, */
  114. /* one the address of the source string and the other the address of */
  115. /* of the result string.  Be careful!  They do not check for any */
  116. /* limits to the string sizes.  P.S. the other routine is called ptocstr */
  117.  
  118.    ctopstr(title,ptitle);
  119.    TRAP(SETRECT,&boundrect,5:W,45:W,507:W,337:W);
  120.    windptr=TRAP:L(NEWWINDOW,0,&boundrect,ptitle,1:B,4:W,-1,0:B,0);   
  121.    TRAP(SETPORT,windptr);
  122.    TRAP(TEXTFONT,4:W);
  123.    TRAP(TEXTSIZE,9:W);
  124.    TRAP(SETRECT,&viewrect,4:W,5:W,482:W,290:W);
  125.    tehnd=TRAP:L(TENEW,&viewrect,&viewrect);
  126.    
  127.    curtop=0;
  128.    TRAP(SETRECT,&boundrect,488:W,0:W,504:W,292:W);
  129.    scrollhnd=TRAP:L(NEWCONTROL,windptr:L,&boundrect,"",1:B,0:W,0:W,0:W,
  130.       16:W,0:L);
  131.    
  132. }
  133.  
  134. closewindow()  /* Close the window opened by openwindow */
  135.  
  136. {
  137.     TRAP(TEDISPOSE,tehnd:L);
  138.     TRAP(DISPOSEWINDOW,windptr);  /* simple */
  139.     windptr=0;
  140.     tehnd=0;
  141.     scrollhnd=0;
  142. }
  143.  
  144. update()
  145.  
  146. {
  147.     TRAP(SETPORT,windptr);
  148.     TRAP(BEGINUPDATE,windptr);
  149.     TRAP(TEUPDATE,&viewrect,tehnd:L);
  150.     TRAP(DRAWCONTROLS,windptr:L);
  151.     TRAP(ENDUPDATE,windptr);
  152. }
  153. putachar(c)
  154.     char   c;
  155. {
  156.     int    charpos;
  157.  
  158.     TRAP(TEKEY,c:W,tehnd:L);
  159.     setscrollmax();
  160.  
  161. }
  162.  
  163. events()
  164.  
  165. {
  166.    int    event;
  167.    
  168.    if(tehnd)TRAP(TEIDLE,tehnd:L);
  169.    if(TRAP:B(GETNEXTEVENT,0xffff:W,&seventrec))  /* trap any event */
  170.      {
  171.  
  172. /* getword is a special function writen in assembler to get a */
  173. /* two byte word from the specified address.  It is a quick and */
  174. /* useful way to get at some of the Macintosh data structures */
  175. /* Going the other way, we have a routine call putword(address,value) */
  176. /* that puts a word anywhere you want.  It would be nice to */
  177. /* have these for long words as well, though there is a way using */
  178. /* C that we show you later. */
  179.  
  180.       event=getword(&seventrec);  /* get the event */
  181.       if(event==1)return domouse();
  182.       else if(event==3)return keydown();
  183.       else if(event==5)return keydown();
  184.       else if(event==6)update();
  185.       else if(event==8)activate();
  186.      }
  187.    return 0;
  188. }
  189.  
  190. activate()
  191.  
  192. {
  193.    if(getword(&seventrec[14])&1)
  194.      {  /* activate */
  195.      TRAP(TEACTIVATE,tehnd);
  196.      }
  197.    else
  198.      {  /* deactivate */
  199.      TRAP(TEDEACTIVATE,tehnd);
  200.      }
  201. }
  202.  
  203. keydown()
  204. {
  205.    int   modifiers;
  206.    char  thekey;
  207.  
  208.    modifiers=getword(&seventrec[14]);
  209.    thekey=seventrec[5];
  210.    if(modifiers&256)
  211.      {
  212.      return domenu(TRAP:L(MENUKEY,thekey:W));
  213.      } 
  214.    else /* it a character so print it */
  215.      {
  216.      putachar(thekey);  /* a return key */
  217.      }
  218.    return 0;
  219. }
  220.  
  221.  
  222. domouse()
  223. {
  224.    int    *evwhere,windowloc,wwindptr,mselected,where,whichpart,wcntlhnd;
  225.    
  226.    evwhere=&seventrec[10];
  227.    where=*evwhere;
  228.    windowloc=TRAP:W(FINDWINDOW,where:L,&wwindptr:L);
  229.    if(windowloc==1)    /* in menubar */
  230.       { 
  231.       mselected=TRAP:L(MENUSELECT,where:L);
  232.       return domenu(mselected);
  233.       }
  234.    else if(windowloc==3)  /* in content of window.  This can be */
  235.                           /* the text part or the scrollbar */
  236.       {
  237.       TRAP(GLOBALTOLOCAL,&where);
  238.       whichpart=TRAP:W(FINDCONTROL,where:L,windptr:L,&wcntlhnd:L);
  239.  
  240.       if(whichpart==0)selecttext(where);  /* in the text part */
  241.  
  242.                /* now check if in the scrollbar parts */
  243.  
  244.       else if(whichpart==20)doscroll(whichpart,-1);  /* up button */
  245.       else if(whichpart==21)doscroll(whichpart,1);   /* down button */
  246.       else if(whichpart==22)doscroll(whichpart,-pagelines);  /* up page */
  247.       else if(whichpart==23)doscroll(whichpart,pagelines);  /* down page */
  248.       else if(whichpart==129)   /* in the thumb */
  249.          {      
  250.                  /* this next automatically tracks the mouse in */
  251.                  /* the thumb, and sets the ctlvalue for you */
  252.  
  253.          if(TRAP:W(TRACKCONTROL,scrollhnd:L,where:L,0:L)==129)  
  254.            scroll();
  255.          }
  256.       } 
  257.    return 0;
  258.    
  259. }
  260.  
  261. doscroll(whichpart,linestoscroll)
  262.    int    whichpart,linestoscroll;
  263.  
  264. {
  265.    int    wheremouse;
  266.  
  267.    while(TRAP:B(STILLDOWN))   /* If you haven't let go of the mouse yet */
  268.      {
  269.      TRAP(GETMOUSE,&wheremouse);  /* Where is it now? */
  270.      if(TRAP:W(TESTCONTROL,scrollhnd:L,wheremouse)==whichpart) /* there yet?*/
  271.        {                           
  272.        TRAP(HILITECONTROL,scrollhnd:L,whichpart:W);  /* hilite the part */
  273.        TRAP(SETCTLVALUE,scrollhnd:L,curtop+linestoscroll:W);
  274.        scroll();
  275.        }
  276.      else TRAP(HILITECONTROL,scrollhnd:L,0:W); /* turn off hilite */
  277.      }
  278.    TRAP(HILITECONTROL,scrollhnd:L,0:W); /* make sure you turn off hilite */
  279. }
  280.  
  281. selecttext(where)
  282.    int    where;
  283. {
  284.    if(TRAP:B(PTINRECT,where,&viewrect))  /* Is it in view? */
  285.       {
  286.       TRAP(TECLICK,where:L,0:B,tehnd);  /* Extend is always false here */
  287.       }
  288. }
  289.  
  290. /* This routine is boring, except that it shows how to use C */
  291. /* to find the record a handle ultimately points to.  Note here */
  292. /* we are getting the address of the te record in terec.  At the */
  293. /* address  + an offset of 94bytes is the number of lines in the */
  294. /* te record */
  295.  
  296. setscrollmax()
  297.  
  298. {
  299.    int   *temp;
  300.    char  *terec;
  301.  
  302.    if(tehnd!=0)
  303.      {
  304.      temp=tehnd;
  305.      terec=*temp;          /* terec+94 is number of lines of text */
  306.      TRAP(SETCTLMAX,scrollhnd:L,getword(terec+94):W); 
  307.      }
  308. }
  309.  
  310. scroll()
  311.  
  312. {
  313.     int     oldtop,numbtoscroll;
  314.  
  315.     oldtop=curtop;
  316.     curtop=TRAP:W(GETCTLVALUE,scrollhnd:L);
  317.     numbtoscroll= (oldtop-curtop)*11;  /* 11 is height of monaco 9 line */
  318.        /* scrolling 0 has been known to have strange effects, so we don't */
  319.     if(numbtoscroll!=0)TRAP(TESCROLL,0:W,numbtoscroll:W,tehnd:L);
  320. }
  321.  
  322. domenu(menuinfo)
  323.  
  324.    int  menuinfo;
  325. {
  326.    int    menu,menuitem;
  327.    int    in,volref;
  328.    char   filename[64],pfilename[64];
  329.  
  330.    menu=getword(&menuinfo);
  331.    menuitem=getword(&menuinfo+2);
  332.    if(menu==33)  /* file menu */
  333.      {
  334.      if (menuitem==1)
  335.        {   /* new window */
  336.        if(windptr==0)openwindow("untitled");
  337.        }
  338.      else if(menuitem==2)
  339.        {   /* open file and window */
  340.        if(windptr==0)
  341.          {
  342.          volref=getfile(filename);  /* returns 0 if cancelled */
  343.          if(volref)
  344.             {
  345.             openwindow(filename);
  346.             readfile(filename,volref);
  347.             }
  348.          }
  349.        }
  350.      else if(menuitem==3)
  351.        {
  352.        if(windptr!=0)
  353.          {
  354.          TRAP(GETWTITLE,windptr:L,&pfilename);
  355.          ptocstr(pfilename,filename);  /* this seems dumb */
  356.          volref=putfile(filename,"Save the file as...",filename);
  357.          if(volref)
  358.            {
  359.            writefile(filename,volref);
  360.            }
  361.          closewindow();  /* Close the window even if cancel save. */
  362.                          /* We really should go back to the window */
  363.                          /* but this is kept simple. */
  364.          }
  365.        }
  366.      else if(menuitem==8) return 1;       /* quitting time */
  367.      }
  368.    else if(menu==34) /* edit menu */
  369.      {
  370. /* An editorial comment: The Mac really makes cutting and pasting a snap */
  371. /* This next stuff is ridculously easy */
  372.  
  373.      if(menuitem==3)TRAP(TECUT,tehnd:L);
  374.      else if(menuitem==4)TRAP(TECOPY,tehnd:L);
  375.      else if(menuitem==5)TRAP(TEPASTE,tehnd:L);
  376.      else if(menuitem==6)TRAP(TEDELETE,tehnd:L);  /* clear */
  377.      else if(menuitem==7)TRAP(TESETSELECT,0:L,0XFFFF:L,tehnd:L); /* sel all*/
  378.      setscrollmax();
  379.      }
  380.    TRAP(HILITEMENU,0:W);  /* unlite all menus items */
  381.    return 0;
  382. }
  383.  
  384. /* Read a file into the te record.  It reads the entire file all */
  385. /* at once, which makes it rather fast. Everything here can be used */
  386. /* to do the regular kind of stuff... open a file, read a line into a */
  387. /* a buffer (rather than into the te record directly), read until you */
  388. /* reach an end of file, eventually close the file.  It is just a matter */
  389. /* of creating space for a buffer and then using these same things to */
  390. /* read into it a set amount repeatedly. I did it this way just to */
  391. /* show how to do it fast and neat */
  392.  
  393. /* Readfile and writefile use an assembler routine, PBIO, that requires */
  394. /* an address for the parameter block and a trap number. */
  395. /* In effect PBIO gives you access to all the PB routines */
  396. /* from the toolbox */
  397.  
  398. /* These routines really demonstrate how to play with non-simple */
  399. /* structures using C and the getword/putword routines.  It is a bit */
  400. /* of a pain to get just right.  If you have any problems, it is */
  401. /* useful to look at the assembler listing that the compiler */
  402. /* makes.  You do this by selecting C Compile with Listing... instead of */
  403. /* C Compile...   Another idea is to write in C or assembler some */
  404. /* simple conversion and assignment routines.  (that's what I'm going to do) */
  405.  
  406. /* One thing to be careful of is that pointers know what kind of thing */
  407. /* they point to.  In this case laddress+20 returns an address 80 bytes */
  408. /* offset from the value in laddress, while terec+20 returns an address */
  409. /* offset 20 bytes. */
  410.  
  411. readfile(filename,volref)
  412.    char    filename[];
  413.    int     volref;
  414.  
  415. {
  416.    char    pfilename[64];
  417.    char    *terec;
  418.    int     *laddress,*laddr2,retcode,i,filelen;
  419.  
  420. /* open the file */
  421.    
  422.  
  423.    for(i=0;i<100;i++)pblock[i]=0;  /* initialize pblock */
  424.    ctopstr(filename,pfilename);
  425.    laddress=&pblock[18];
  426.    *laddress=pfilename;            /* insert filename in pblock */
  427.    putword(&pblock[22],volref);    /* insert volrefnumber */
  428.    pblock[26]=0;                   /* set permission to 0 */
  429.    pblock[27]=1;                   /* set read permission */
  430.    laddress=&pblock[28];
  431.    *laddress=0;                    /* set buffer to nil to use volume buffer */
  432.    retcode=pbio(0XA000,&pblock);   /* open for read */
  433.  
  434.    if(retcode!=0) return retcode;   /* if error don't go on */
  435.  
  436. /* get filesize */
  437.  
  438.    retcode=pbio(0XA011,&pblock);   /* get eof */
  439.    laddress=&pblock[28];           /* size stored at offset 28 */
  440.    filelen=*laddress;
  441.  
  442.    if(retcode!=0) return retcode;   /* if error don't go on */
  443.  
  444. /* set text handlesize */
  445.  
  446.    laddress=tehnd;
  447.    terec=*laddress;
  448.    laddress=terec+62;  /* where the text handle is found */
  449.    retcode=sethandlesize(*laddress,filelen);   /* resize the text in terec */
  450.    
  451.    if(retcode!=0) return retcode;   /* if error don't go on */
  452.    
  453. /* read the entire file */
  454.    
  455.    laddress=tehnd;
  456.    terec=*laddress;
  457.    laddress=terec+62;  /* get the text handle */
  458.  
  459.    laddr2=*laddress;   /* get address of start of text */
  460.    laddr2=*laddr2;      /* I love handles, don't you? */
  461.    laddress=&pblock[32];
  462.    *laddress=laddr2;  /* put start of text address into pblock */
  463.    laddress=&pblock[36];
  464.    *laddress=filelen;
  465.    putword(&pblock[44],0);  /* no newline character */
  466.    laddress=&pblock[46];
  467.    *laddress=0;   /* set offset to 0 */
  468.    retcode=pbio(0XA002,&pblock);
  469.  
  470. /* close the file */
  471.  
  472.    retcode=pbio(0XA001,&pblock);   /* close it */
  473.  
  474.    recaltext(filelen);
  475.  
  476.  
  477. }
  478.  
  479. recaltext(filelen)
  480.  
  481.    int  filelen;
  482.  
  483. {
  484.    int  *laddress;
  485.    char *terec;
  486.  
  487.    laddress=tehnd;
  488.    terec=*laddress;
  489.    putword(terec+60,filelen);
  490.    TRAP(TECALTEXT,tehnd:L);
  491.    TRAP(TESETSELECT,0:L,0:L,tehnd:L);  /* set select to start */
  492.    setscrollmax();
  493. }
  494.  
  495. /* write the entire terecord out to a disk file */
  496.  
  497. writefile(filename,volref)
  498.  
  499.    char   filename[];
  500.    int    volref;
  501.  
  502. {
  503.    char    pfilename[64];
  504.    char    *terec;
  505.    int     *laddress,*laddr2,retcode,i,filelen;
  506.  
  507. /* open the file */
  508.    
  509.  
  510.    ctopstr(filename,pfilename);
  511.    laddress=&pblock[18];
  512.    *laddress=pfilename;            /* insert filename in pblock */
  513.    putword(&pblock[22],volref);    /* insert volrefnumber */
  514.    pblock[26]=0;                   /* set permission to 0 */
  515.    pblock[27]=2;                   /* set write permission */
  516.    laddress=&pblock[28];
  517.    *laddress=0;                    /* set buffer to nil to use volume buffer */
  518.    retcode=pbio(0XA000,&pblock);   /* open for write */
  519.  
  520. /* if file doesn't exist retcode=-43, so create it */
  521.    if(retcode==-43)retcode=createfile(filename,volref);
  522.  
  523.    if(retcode!=0) return retcode;   /* if error don't go on */
  524.    
  525. /*write the entire file */
  526.    
  527.    laddress=tehnd;
  528.    terec=*laddress;
  529.    laddress=terec+62;  /* get the text handle */
  530.    laddr2=*laddress;   /* get address of start of text */
  531.    filelen=getword(terec+60); /* get cur text length from terec */
  532.   
  533.    laddr2=*laddr2;      /* I love handles, don't you? */
  534.    laddress=&pblock[32];
  535.    *laddress=laddr2;  /* put start of text address into pblock */
  536.    laddress=&pblock[36];
  537.    *laddress=filelen;
  538.    putword(&pblock[44],1);  /* set pos mode for start of file */
  539.    laddress=&pblock[46];
  540.    *laddress=0;   /* set offset to 0 */
  541.    retcode=pbio(0XA003,&pblock);
  542.  
  543. /* set the file eof */
  544.  
  545.    laddress=&pblock[28];
  546.    laddr2=&pblock[40];
  547.    *laddress=*laddr2;  /* store the io count from write */
  548.    retcode=pbio(0XA012,&pblock);
  549.  
  550. /* close the file */
  551.  
  552.    retcode=pbio(0XA001,&pblock);   /* close it */
  553.  
  554. /* flush the volume */
  555.  
  556.    laddress=&pblock[18];
  557.    *laddress=0;                    /* set name to 0, volref is enough */
  558.    retcode=pbio(0XA013,&pblock);  /* flush away */
  559.  
  560. }
  561.  
  562.  
  563. createfile(filename,volref)
  564.  
  565.    char   filename[];
  566.    int    volref;
  567.  
  568. {
  569.    char    pfilename[64];
  570.    char    *terec;
  571.    int     *laddress,*laddr2,retcode,i,filelen;
  572.  
  573. /* open the file */
  574.    
  575.  
  576.    ctopstr(filename,pfilename);
  577.    laddress=&pblock[18];
  578.    *laddress=pfilename;            /* insert filename in pblock */
  579.    putword(&pblock[22],volref);    /* insert volrefnumber */
  580.    pblock[26]=0;                   /* set version to 0 */
  581.    retcode=pbio(0XA008,&pblock);   /* create it */
  582.  
  583.    if(retcode!=0) return retcode;
  584.  
  585. /* get the fileinfo */
  586.  
  587.    laddress=&pblock[18];
  588.    *laddress=pfilename;            /* insert filename in pblock */
  589.    putword(&pblock[22],volref);    /* insert volrefnumber */
  590.    pblock[26]=0;                   /* set version to 0 */
  591.    putword(&pblock[28],0);         /* set dir index to 0 */
  592.    retcode=pbio(0XA00C,&pblock);   /* get file info */
  593.  
  594. /* set the fileinfo */
  595. /* use the fileinfo we just got, and set type to text */
  596.  
  597.    pblock[32]='T';
  598.    pblock[33]='E';
  599.    pblock[34]='X';
  600.    pblock[35]='T';
  601.  
  602. /* you could set the creator to something here */
  603.  
  604.    retcode=pbio(0XA00D,&pblock);   /* set file info */
  605.  
  606. /* now try opening it again */
  607.   
  608.    laddress=&pblock[18];
  609.    *laddress=pfilename;            /* insert filename in pblock */
  610.    putword(&pblock[22],volref);    /* insert volrefnumber */
  611.    pblock[26]=0;                   /* set permission to 0 */
  612.    pblock[27]=2;                   /* set write permission */
  613.    laddress=&pblock[28];
  614.    *laddress=0;                    /* set buffer to nil to use volume buffer */
  615.    retcode=pbio(0XA000,&pblock);   /* open for write */
  616.  
  617.    return retcode;
  618. }
  619.  
  620.  
  621. /* output a decimal number  */
  622. outdec(n)
  623. int n;
  624. {
  625.        if(n<0)
  626.                putachar('-');
  627.        else    n = -n;
  628.        outint(n);
  629. /* end outdec */}
  630.  
  631. outint(n)      
  632. int n;
  633. {      int q;
  634.  
  635.        q = n/10;
  636.        if(q) outint(q);
  637.        putachar('0'-(n-q*10));
  638. /* end outint */}
  639.  
  640. wait()
  641. {
  642.    int event;
  643.  
  644.    while(1)
  645.      {
  646.      if(TRAP:B(GETNEXTEVENT,0XFFFF:W,&seventrec)) /* trap any event */
  647.        {
  648.        event=getword(&seventrec);  
  649.        if(event==1)break; /* mouse */
  650.        if(event==3)break; /* keydown */
  651.        }
  652.      }
  653. }